/**
 * Notes: 大语言模型服务
 * Date: 2023-10-01 19:40:00 
 */

const BaseProjectService = require('../base_project_service.js');
const util = require('../../../../framework/utils/util.js');
const timeUtil = require('../../../../framework/utils/time_util.js');
const config = require('../../../../config/config.js');
const https = require('https');

class LLMService extends BaseProjectService {

    /**
     * 发送请求到LLM服务
     * 注意：这是一个示例，实际应用中请替换为您自己的API密钥和端点
     */
    async sendRequest(messages, temperature = 0.7) {
        // 在实际应用中，您需要填写自己的API密钥和端点URL
        const apiKey = process.env.OPENAI_API_KEY || ''; // 从环境变量获取API密钥
        const endpoint = process.env.OPENAI_API_ENDPOINT || 'https://api.openai.com/v1/chat/completions';
        
        if (!apiKey) {
            console.error('未配置API密钥，无法访问LLM服务');
            return { error: '服务配置错误，请联系管理员' };
        }

        const data = JSON.stringify({
            model: "gpt-3.5-turbo",  // 可以根据需要更换为其他模型
            messages: messages,
            temperature: temperature,
            max_tokens: 1000
        });

        const options = {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${apiKey}`
            }
        };

        return new Promise((resolve, reject) => {
            try {
                const req = https.request(endpoint, options, (res) => {
                    let responseData = '';
                    
                    res.on('data', (chunk) => {
                        responseData += chunk;
                    });
                    
                    res.on('end', () => {
                        try {
                            const parsedData = JSON.parse(responseData);
                            resolve(parsedData);
                        } catch (error) {
                            console.error('解析LLM响应失败:', error);
                            resolve({ error: '服务响应异常' });
                        }
                    });
                });
                
                req.on('error', (error) => {
                    console.error('LLM请求失败:', error);
                    resolve({ error: '网络请求失败' });
                });
                
                req.write(data);
                req.end();
            } catch (error) {
                console.error('发送LLM请求异常:', error);
                resolve({ error: '服务请求异常' });
            }
        });
    }

    /**
     * 使用RAG技术生成回答
     * @param {string} query - 用户问题
     * @param {Array} documents - 检索到的相关文档
     * @param {string} sessionId - 会话ID，用于上下文跟踪
     */
    async generateAnswer(query, documents, sessionId = '') {
        try {
            // 构建prompt上下文
            const context = documents.map(doc => {
                return `文档标题: ${doc.document.KNOWLEDGE_TITLE}\n内容: ${doc.document.KNOWLEDGE_CONTENT}\n相关度: ${doc.score.toFixed(2)}`;
            }).join('\n\n');
            
            // 构建系统提示词
            const systemPrompt = `你是一个电力系统知识专家助手，名为"电力智能助手"。
请基于提供的知识库文档来回答用户的问题。
如果知识库中有相关信息，请直接使用这些信息来构建回答。
如果知识库中没有相关信息，请礼貌地告知用户你没有这方面的信息，并建议他们联系专业人员。
回答应当简洁、准确、专业，避免过度解释。
不要在回答中提及你正在使用的知识库文档或相关度分数等技术细节。`;

            // 构建用户消息
            const userMessage = `我的问题是: ${query}\n\n以下是相关的知识库内容:\n${context}`;
            
            // 构建消息数组
            const messages = [
                { role: "system", content: systemPrompt },
                { role: "user", content: userMessage }
            ];
            
            // 发送请求到LLM
            const response = await this.sendRequest(messages);
            
            if (response.error) {
                return { success: false, message: response.error };
            }
            
            if (response.choices && response.choices.length > 0) {
                const answer = response.choices[0].message.content;
                return {
                    success: true,
                    answer: answer,
                    documents: documents.map(doc => ({
                        id: doc.document._id,
                        title: doc.document.KNOWLEDGE_TITLE,
                        score: doc.score
                    }))
                };
            } else {
                return { success: false, message: '无法生成回答' };
            }
            
        } catch (error) {
            console.error('生成回答失败:', error);
            return { success: false, message: '服务异常，请稍后再试' };
        }
    }

    /**
     * 模拟LLM回答（当无法连接实际API时使用）
     */
    async mockGenerateAnswer(query, documents) {
        try {
            // 如果有相关文档
            if (documents && documents.length > 0) {
                // 取分数最高的文档
                const topDoc = documents[0].document;
                
                // 简单的响应模板
                return {
                    success: true,
                    answer: `根据我的知识库，关于"${query}"的问题，我可以告诉您：\n\n${topDoc.KNOWLEDGE_CONTENT.substring(0, 200)}...\n\n希望这个回答对您有所帮助！`,
                    documents: documents.map(doc => ({
                        id: doc.document._id,
                        title: doc.document.KNOWLEDGE_TITLE,
                        score: doc.score
                    }))
                };
            } else {
                // 无相关文档时
                return {
                    success: true,
                    answer: `对不起，我在知识库中没有找到关于"${query}"的相关信息。请您联系专业人员获取更准确的答案，或者尝试其他相关问题。`,
                    documents: []
                };
            }
        } catch (error) {
            console.error('模拟回答生成失败:', error);
            return { success: false, message: '服务异常，请稍后再试' };
        }
    }
}

module.exports = LLMService; 